package com.clstu.threaduse;

public class Thread02 {
    public static void main(String[] args) {
        //Dog.start();//这个方法不可行，因为没有继承Thread类
        //Dog.run();//这个方法更加愚蠢，这是串行执行，就是调用了普通的run()方法，不是并行
//        Thread thread = new Thread(new Dog());
//        thread.start();//这里用到了静态代理模式
        int time = 0;
        new Proxy(new Dog()).start();//静态代理,
        while (true) {
            System.out.println("哈哈哈！！！~~~======"+(++time)+"---"+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (time>40) break;
        }

    }
}
class Dog implements Runnable{
    int time=0;
    @Override
    public void run() {

        while (true) {
                System.out.println("汪汪汪！！！~~~======"+(++time)+"---"+Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (time>40) break;
            }
    }

}

class Proxy implements Runnable{//模拟了一个极简的Thread类
                            //但是这个类只是模拟的原理，理清了调用关系，并不能真正的实现多线程
                          //因为start0()不对应，所以实现不了
    //                      要真正实现多线程还是得通过Thread类来代理或者继承Thread类

    private Runnable target = null;

    @Override
    public void run() {
         if(target!=null) target.run();
    }

    public Proxy(Runnable target) {
        this.target = target;
    }

    public void start(){//必须使用这样的嵌套调用才能够实现多线程。
        start0();//真正实现多线程的方法
    }

    public void start0(){
        run();//调用run()，注意：这里的run()不是target.run();但是最终是调用target.run();
    }
}